Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## rdlc.rdl
Class DynRoot_Standard

    java.lang.Object
      rdlc.rdl.Declaration_Named
          rdlc.rdl.DynRoot_Standard

All Implemented Interfaces:
  Declaration, DynRoot, Expression

Direct Known Subclasses:
  Class, Map_Standard, Module, Platform_Standard, Unit_Standard

    public abstract class DynRoot_Standard

extends Declaration_Named
implements DynRoot

Simple helper class which implements the generic functionality required of a `DynRoot`. Handles management of the interesting properties which the `DynRoot` interface provides accessors for.

Version:
  $Revision: 1.11 $
Author:
  Greg Gibeling

Nested Class Summary

Nested classes/interfaces inherited from interface rdlc.rdl.Expression
`Expression.Phase`

Field Summary
`protected Instance` | `instance` The instance which corresponds with this `DynRoot`.
`protected boolean` | `isLeaf` Is this a leaf declaration? This implies it has no children in the dynamic hierarchy (or at least no children which are DynRoots themselves).
`protected boolean` | `isRoot` Is this a root declaration? This would imply that it can be processed without knowledge of a parent declaration in a dynamic hierarchy.

Fields inherited from class rdlc.rdl.Declaration_Named
`iName, namespace, rawStaticID`

Constructor Summary
`DynRoot_Standard()`
`DynRoot_Standard(Namespace _namespace)`
`DynRoot_Standard(java.lang.String _name, Namespace _namespace)` Creates this named dynamic root declaration in the given namespace.

Method Summary
`Instance` | `getInstance()` Simple accessor.
`java.lang.String` | `getLambdaName()` Since all dynamic roots will be named it is safe to simply get the name this was declared with and report it as the lambda name.
`void` | `getRequirements(CatalogSet<Identifier<Declaration>> requirements)` For a dynamic root, we must also take the requirements of it's fields into account.
`boolean` | `isLeaf()` Simple accessor.
`boolean` | `isRoot()` Simple accessor.
`void` | `setNamespace(Namespace _namespace)` Takes care of setting not only the namespace for this declaration, but for the entire dynamic hierarchy rooted at this declaration.
`boolean` | `typeMatch(Expression e)` Dynamic root constructs in RDL will never type match unless they are actually identical.

Methods inherited from class rdlc.rdl.Declaration_Named
`getBase, getIdentifier, getNamedBase, getRawStaticID, getType, resolve, setRawStaticID, toString`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

Methods inherited from interface rdlc.rdl.Declaration
`getBase, getIdentifier, getNamedBase, getType, setRawStaticID`

Methods inherited from interface rdlc.rdl.Expression
`resolve`

Field Detail

### instance

    protected Instance instance

  The instance which corresponds with this `DynRoot`.

### isRoot

    protected boolean isRoot

  Is this a root declaration? This would imply that it can be processed without knowledge of a parent declaration in a dynamic hierarchy.

### isLeaf

    protected boolean isLeaf

  Is this a leaf declaration? This implies it has no children in the dynamic hierarchy (or at least no children which are DynRoots themselves).

Constructor Detail

### DynRoot_Standard

    public DynRoot_Standard()

See Also:
  `Declaration_Named.Declaration_Named()`

### DynRoot_Standard

    public DynRoot_Standard(Namespace _namespace)

See Also:
  `Declaration_Named.Declaration_Named(Namespace)`

### DynRoot_Standard

    public DynRoot_Standard(java.lang.String _name,
                            Namespace _namespace)

  Creates this named dynamic root declaration in the given namespace. If the namespace is not null, this declaration will be added to it. Either way this declaration will be fully resolved.

  Parameters:
    `_name` - The name to use for this dynamic root.
    `_namespace` - The namespace in which this dynamic root belongs.

Method Detail

### getInstance

    public Instance getInstance()

  Description copied from interface: `DynRoot`
  Simple accessor.

  Specified by:
    `getInstance` in interface `DynRoot`
  Returns:
    The instance which marks the root of this dynamic hierarchy.
  See Also:
    `DynRoot.getInstance()`

### isLeaf

    public boolean isLeaf()

  Description copied from interface: `DynRoot`
  Simple accessor.

  Specified by:
    `isLeaf` in interface `DynRoot`
  Returns:
    `true` if this is a leaf declaration (one which has no children).
  See Also:
    `DynRoot.isLeaf()`

### isRoot

    public boolean isRoot()

  Description copied from interface: `DynRoot`
  Simple accessor.

  Specified by:
    `isRoot` in interface `DynRoot`
  Returns:
    `true` if this is a root declaration (one which can be handled regardless of a parent).
  See Also:
    `DynRoot.isRoot()`

### setNamespace

    public void setNamespace(Namespace _namespace)

  Takes care of setting not only the namespace for this declaration, but for the entire dynamic hierarchy rooted at this declaration.

  Specified by:
    `setNamespace` in interface `Expression`
  Overrides:
    `setNamespace` in class `Declaration_Named`
  Parameters:
    `_namespace` - The namespace in which this declaration was declared. This may not be the same as the one in which it is eventually bound.
  See Also:
    `Declaration_Named.setNamespace(Namespace)`

### typeMatch

    public boolean typeMatch(Expression e)

  Dynamic root constructs in RDL will never type match unless they are actually identical. This method takes care of resolving any indirection and then does an object equality test.

  Specified by:
    `typeMatch` in interface `Expression`
  Parameters:
    `e` - The expression to check this one against.
  Returns:
    `true` if these two expressions match in type.
  See Also:
    `Expression.typeMatch(Expression)`

### getLambdaName

    public java.lang.String getLambdaName()

  Since all dynamic roots will be named it is safe to simply get the name this was declared with and report it as the lambda name.

  Specified by:
    `getLambdaName` in interface `Declaration`
  Returns:
    A name for this type, which can be used for types which were unnamed in RDL.
  See Also:
    `Declaration.getLambdaName()`

### getRequirements

    public void getRequirements(CatalogSet<Identifier<Declaration>> requirements)

  For a dynamic root, we must also take the requirements of it's fields into account.

  Specified by:
    `getRequirements` in interface `Expression`
  Overrides:
    `getRequirements` in class `Declaration_Named`
  Parameters:
    `requirements` - A list to which this will add the declarations upon which this one relies.

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD